home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 February / EnigmA AMIGA RUN 15 (1997)(G.R. Edizioni)(IT)[!][issue 1997-02][PLANET CD V].iso / enigma / earcd / emula / arosdv19.lha / AROS / dos / matchpatternnocase.c < prev    next >
C/C++ Source or Header  |  1996-10-24  |  8KB  |  304 lines
  1. /*
  2.     (C) 1995-96 AROS - The Amiga Replacement OS
  3.     $Id: matchpatternnocase.c,v 1.2 1996/10/24 15:50:33 aros Exp $
  4.     $Log: matchpatternnocase.c,v $
  5.     Revision 1.2  1996/10/24 15:50:33  aros
  6.     Use the official AROS macros over the __AROS versions.
  7.  
  8.     Revision 1.1  1996/09/11 12:54:46  digulla
  9.     A couple of new DOS functions from M. Fleischer
  10.  
  11.     Desc:
  12.     Lang: english
  13. */
  14. #include <exec/memory.h>
  15. #include <clib/exec_protos.h>
  16. #include <clib/utility_protos.h>
  17. #include <dos/dosextens.h>
  18. #include "dos_intern.h"
  19.  
  20. /*****************************************************************************
  21.  
  22.     NAME */
  23.     #include <clib/dos_protos.h>
  24.  
  25.     AROS_LH2(BOOL, MatchPatternNoCase,
  26.  
  27. /*  SYNOPSIS */
  28.     AROS_LHA(STRPTR, pat, D1),
  29.     AROS_LHA(STRPTR, str, D2),
  30.  
  31. /*  LOCATION */
  32.     struct DosLibrary *, DOSBase, 162, Dos)
  33.  
  34. /*  FUNCTION
  35.     Similar to MatchPattern(), only case insensitive (see there for
  36.     more information). For use with ParsePatternNoCase().
  37.  
  38.     INPUTS
  39.  
  40.     RESULT
  41.  
  42.     NOTES
  43.  
  44.     EXAMPLE
  45.  
  46.     BUGS
  47.  
  48.     SEE ALSO
  49.     MatchPattern(), ParsePatternNoCase().
  50.  
  51.     INTERNALS
  52.  
  53.     HISTORY
  54.     29-10-95    digulla automatically created from
  55.                 dos_lib.fd and clib/dos_protos.h
  56.  
  57. *****************************************************************************/
  58. {
  59.     AROS_LIBFUNC_INIT
  60.     AROS_LIBBASE_EXT_DECL(struct DosLibrary *,DOSBase)
  61.  
  62.     STRPTR s;
  63.     LONG match=0;
  64.     struct markerarray ma, *macur=&ma, *cur2;
  65.     LONG macnt=0, cnt2;
  66.     ULONG level;
  67.     UBYTE a, b, c, t;
  68.     LONG error;
  69. #define ERROR(a) { error=(a); goto end; }
  70.  
  71.     ma.next=ma.prev=NULL;
  72.     for(;;)
  73.         switch(*pat)
  74.         {
  75.             case MP_MULT: /* _#(_a) */
  76.                 PUSH(0,++pat,str);
  77.                 level=1;
  78.                 for(;;)
  79.                 {
  80.                     c=*pat++;
  81.                     if(c==MP_MULT)
  82.                         level++;
  83.                     else if(c==MP_MULT_END)
  84.                         if(!--level)
  85.                             break;
  86.                 }
  87.                 break;
  88.             case MP_MULT_END: /* #(a_)_ */
  89.                 level=1;
  90.                 for(;;)
  91.                 {
  92.                     c=*--pat;
  93.                     if(c==MP_MULT_END)
  94.                         level++;
  95.                     else if(c==MP_MULT)
  96.                         if(!--level)
  97.                             break;
  98.                 }
  99.                 break;
  100.             case MP_NOT: /* _~(_a) */
  101.                 s=++pat;
  102.                 level=1;
  103.                 for(;;)
  104.                 {
  105.                     c=*s++;
  106.                     if(c==MP_NOT)
  107.                         level++;
  108.                     else if(c==MP_NOT_END)
  109.                         if(!--level)
  110.                             break;
  111.                 }
  112.                 PUSH(1,s,str);
  113.                 break;
  114.             case MP_NOT_END: /* ~(a_)_ */
  115.                 cnt2=macnt;
  116.                 cur2=macur;
  117.                 do
  118.                 {
  119.                     cnt2--;
  120.                     if(cnt2<0)
  121.                     {
  122.                         cnt2=127;
  123.                         cur2=cur2->prev;
  124.                     }
  125.                 }while(!cur2->marker[cnt2].type);
  126.                 if(!*str++)
  127.                 {
  128.                     macnt=cnt2;
  129.                     macur=cur2;
  130.                 }else
  131.                     if(str>cur2->marker[cnt2].str)
  132.                         cur2->marker[cnt2].str=str;
  133.                 POP(t,pat,str);
  134.                 if(t&&*str)
  135.                 { PUSH(1,pat,str+1); }
  136.                 break;
  137.             case MP_OR: /* ( */
  138.                 s=++pat;
  139.                 level=1;
  140.                 for(;;)
  141.                 {
  142.                     c=*s++;
  143.                     if(c==MP_OR)
  144.                         level++;
  145.                     else if(c==MP_OR_NEXT)
  146.                     {
  147.                         if(level==1)
  148.                         { PUSH(0,s,str); }
  149.                     }else if(c==MP_OR_END)
  150.                         if(!--level)
  151.                             break;
  152.                 }
  153.                 break;
  154.             case MP_OR_NEXT: /* | */
  155.                 pat++;
  156.                 level=1;
  157.                 for(;;)
  158.                 {
  159.                     c=*pat++;
  160.                     if(c==MP_OR)
  161.                         level++;
  162.                     else if(c==MP_OR_END)
  163.                         if(!--level)
  164.                             break;
  165.                 }
  166.                 break;
  167.             case MP_OR_END: /* ) */
  168.                 pat++;
  169.                 break;
  170.             case MP_SINGLE: /* ? */
  171.                 pat++;
  172.                 if(*str)
  173.                     str++;
  174.                 else
  175.                 {
  176.                     POP(t,pat,str);
  177.                     if(t&&*str)
  178.                     { PUSH(1,pat,str+1); }
  179.                 }
  180.                 break;
  181.             case MP_SET: /* [ */
  182.                 pat++;
  183.                 for(;;)
  184.                 {
  185.                     a=b=*pat++;
  186.                     if(a==MP_SET_END)
  187.                     {
  188.                         POP(t,pat,str);
  189.                         if(t&&*str)
  190.                         { PUSH(1,pat,str+1); }
  191.                         break;
  192.                     }
  193.                     if(a==MP_ESCAPE)
  194.                         a=b=*pat++ +0x80;
  195.                     else if(a==MP_DASH)
  196.                     {
  197.                         a=*pat++;
  198.                         if(a==MP_ESCAPE)
  199.                             a=*pat++ +0x80;
  200.                         b=*pat++;
  201.                         if(b==MP_ESCAPE)
  202.                             b=*pat++ +0x80;
  203.                     }
  204.                     c=ToLower(*str);
  205.                     if(c>=a&&c<=b)
  206.                     {
  207.                         str++;
  208.                         while(*pat++!=MP_SET_END)
  209.                             ;
  210.                         break;
  211.                     }
  212.                 }
  213.                 break;
  214.             case MP_NOT_SET: /* [~ */
  215.                 if(!*str)
  216.                 {
  217.                     POP(t,pat,str);
  218.                     if(t&&*str)
  219.                     { PUSH(1,pat,str+1); }
  220.                     break;
  221.                 }
  222.                 pat++;
  223.                 for(;;)
  224.                 {
  225.                     a=b=*pat++;
  226.                     if(a==MP_SET_END)
  227.                     {
  228.                         str++;
  229.                         break;
  230.                     }
  231.                     if(a==MP_ESCAPE)
  232.                         a=b=*pat++ +0x80;
  233.                     else if(a==MP_DASH)
  234.                     {
  235.                         a=*pat++;
  236.                         if(a==MP_ESCAPE)
  237.                             a=*pat++ +0x80;
  238.                         b=*pat++;
  239.                         if(b==MP_ESCAPE)
  240.                             b=*pat++ +0x80;
  241.                     }
  242.                     c=ToLower(*str);
  243.                     if(c>=a&&c<=b)
  244.                     {
  245.                         POP(t,pat,str);
  246.                         if(t&&*str)
  247.                         { PUSH(1,pat,str+1); }
  248.                         break;
  249.                     }
  250.                 }
  251.                 break;
  252.             case MP_ALL: /* #? */
  253.                 /* This often used pattern has extra treatment to be faster */
  254.                 if(*str)
  255.                 { PUSH(0,pat,str+1); }
  256.                 pat++;
  257.                 break;
  258.             case 0:
  259.                 if(!*str)
  260.                 {
  261.                     match=1;
  262.                     ERROR(0);
  263.                 }else
  264.                 {
  265.                     POP(t,pat,str);
  266.                     if(t&&*str)
  267.                     { PUSH(1,pat,str+1); }
  268.                 }
  269.                 break;
  270.             case MP_ESCAPE:
  271.                 pat++;
  272.                 if(0x80+*pat++==*str)
  273.                     str++;
  274.                 else
  275.                 {
  276.                     POP(t,pat,str);
  277.                     if(t&&*str)
  278.                     { PUSH(1,pat,str+1); }
  279.                 }
  280.                 break;
  281.             default:
  282.                 if(*pat++==ToLower(*str))
  283.                     str++;
  284.                 else
  285.                 {
  286.                     POP(t,pat,str);
  287.                     if(t&&*str)
  288.                     { PUSH(1,pat,str+1); }
  289.                 }
  290.                 break;
  291.         }
  292. end:
  293.     macur=ma.next;
  294.     while(macur!=NULL)
  295.     {
  296.         struct markerarray *next=macur->next;
  297.         FreeMem(macur,sizeof(struct markerarray));
  298.         macur=next;
  299.     }
  300.     ((struct Process *)FindTask(NULL))->pr_Result2=error;
  301.     return match;
  302.     AROS_LIBFUNC_EXIT
  303. } /* MatchPatternNoCase */
  304.